﻿using System;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Configuration;
using System.Globalization;
using System.IO;

using Admaco.Data;
using System.Data.SqlClient;
using Admaco.Presentation.Informes;
using Admaco.Logic;

using LumenWorks.Framework.IO.Csv;

namespace Admaco.Presentation
{
    public partial class Principal : Form
    {

        /// <summary>
        /// Usuario conectado al sistema
        /// </summary>
        private static Usuario usuarioConectado;

        /// <summary>
        /// Analisis activo
        /// </summary>
        private static Analisis analisis;

        /// <summary>
        /// Fichero del analisis
        /// </summary>
        private Fichero fichero = new Fichero();

        /// <summary>
        /// Fichero de datos a analizar
        /// </summary>
        private String ficheroDatos;

        /// <summary>
        /// Fichero de clases a analizar
        /// </summary>
        private String ficheroClases;

        /// <summary>
        /// Prioridad del analisis
        /// </summary>
        private Prioridad prioridad = new Prioridad();

        /// <summary>
        /// Ejecucion de analisis Conexiones Laterales
        /// </summary>
        private MConexionesLaterales conexionesLaterales;

        /// <summary>
        /// Ejecucion de analisis Maximum Likelihood
        /// </summary>
        private MMaximumLikelihood maximumLikelihood;

        /// <summary>
        /// Ejecucion de analisis PCA estadistico
        /// </summary>
        private MPCAEstadistico pcaEstadistico;

        /// <summary>
        /// Ejecucion de analisis PCA Neuronal
        /// </summary>
        private MPCANeuronal pcaNeuronal;

        public static Analisis Analisis
        {
            get { return analisis; }
            set { analisis = value; }
        }

        public Fichero Fichero
        {
            get { return fichero; }
            set { fichero = value; }        
        }
        
        public Prioridad Prioridad
        {
            get { return prioridad; }
            set { prioridad = value; }
        }

        public String FicheroDatos
        {
            get { return ficheroDatos; }
            set { ficheroDatos = value; }
        }

        public String FicheroClases
        {
            get { return ficheroClases; }
            set { ficheroClases = value; }
        }

        public static Usuario UsuarioConectado
        {
            get { return usuarioConectado; }
            set { usuarioConectado = value; }
        }
               
        public Principal()
        {
            InitializeComponent();

            // Inicializo instancias de ejecucion de analisis
            conexionesLaterales = MConexionesLaterales.Instance;
            maximumLikelihood = MMaximumLikelihood.Instance;
            pcaEstadistico = MPCAEstadistico.Instance;
            pcaNeuronal = MPCANeuronal.Instance;
        }

        /// <summary>
        /// Inicializa el formulario con los ficheros procesados
        /// </summary>            
        private void Form1_Load(object sender, EventArgs e)
        {
            crystalReportViewer1.Dock=System.Windows.Forms.DockStyle.Fill;
            crystalReportViewer1.DisplayToolbar = true;

            // Carga la lista de ficheros
            cargarListaFicheros();
            
            // Carga la lista con los niveles de prioridad
            Prioridad prioridad = new Prioridad();
            ArrayList prioridades = prioridad.getAll();

            foreach (Prioridad us in prioridades)
            {
                prioridadCombo.Items.Add(us.Nivel);
            }

            // Especifica la prioridad por defecto
            if (prioridadCombo.Items.Count > 3)
            {
                prioridadCombo.SelectedIndex = 2;

                foreach (Prioridad p in prioridades)
                {
                    if (prioridadCombo.Text.Equals(p.Nivel))
                    {
                        Prioridad = p;
                        break;
                    }
                }
            }

            // Deshabilito tabs hasta que el usuario se conecte
            tabControl1.Enabled = false;
        }


        private void salirToolStripMenuItem_Click(object sender, EventArgs e)
        {
            this.Close();
        }

        private void conectarToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Conectar conectar = new Conectar();            
                        
            conectar.ShowDialog(this);

            // Si se ha conectado el usuario satisfactoriamente
            if (Principal.UsuarioConectado != null)
            {
                if (Principal.UsuarioConectado.isAdministrador())
                    adminProcesosToolStripMenuItem.Enabled = true;

                nuevoToolStripMenuItem.Enabled = true;
                administracionToolStripMenuItem.Enabled = true;
                adminUsuariosToolStripMenuItem.Enabled = true;
                datosToolStripMenuItem.Enabled = true;
                desconectarToolStripMenuItem.Enabled = true;
                conectarToolStripMenuItem.Enabled = false;
                abrirToolStripMenuItem.Enabled = true;
                recargarToolStripMenuItem.Enabled = true;

                // muestro la lista de analisis ejecutados
                mostrarListaAnalisis();
                // Crea el reporte
                reportFicheros();

                // Habilito los tabs
                tabControl1.Enabled = true;
                tabControl1.Visible = true;
                tabControl1.SelectedIndex = 0;
                tabPage1.Show();                
            }

        }

        private void adminUsuariosToolStripMenuItem_Click(object sender, EventArgs e)
        {
            AdminUsuarios adminUsuarios = new AdminUsuarios();
            adminUsuarios.ShowDialog();
        }

        private void acercaDeToolStripMenuItem_Click(object sender, EventArgs e)
        {
            AcercaDe acercaDe = new AcercaDe();
            acercaDe.ShowDialog();
        }

        private void desconectarToolStripMenuItem_Click(object sender, EventArgs e)
        {
            DialogResult resultado = MessageBox.Show("¿Está seguro de que desea cerrar la sesión?", 
                "Desconectar", MessageBoxButtons.YesNo, MessageBoxIcon.Warning, MessageBoxDefaultButton.Button2);
            if (resultado == DialogResult.Yes)
            {
                usuarioConectado = null;
                nuevoToolStripMenuItem.Enabled = false;
                desconectarToolStripMenuItem.Enabled = false;
                administracionToolStripMenuItem.Enabled = false;
                adminProcesosToolStripMenuItem.Enabled = false;
                adminUsuariosToolStripMenuItem.Enabled = false;
                datosToolStripMenuItem.Enabled = false;
                conectarToolStripMenuItem.Enabled = true;
                abrirToolStripMenuItem.Enabled = false;
                recargarToolStripMenuItem.Enabled = false;

                tabControl1.Visible = false;
            }
        }

        /// <summary>
        /// Carga la lista de ficheros con los ficheros existentes
        /// </summary>
        private void cargarListaFicheros()
        {
            // Recarga la lista de ficheros            
            ArrayList ficheros = fichero.getAll();

            ficherosCombo.Items.Clear();
            foreach (Fichero us in ficheros)
            {
                ficherosCombo.Items.Add(us.Titulo);
            }
        }

        private void importarFicherosToolStripMenuItem_Click(object sender, EventArgs e)
        {
            new ImportarDatos().ShowDialog();
            cargarListaFicheros();
        }

        private void visualizarFicherosToolStripMenuItem_Click(object sender, EventArgs e)
        {
            new VisualizarDatos().ShowDialog();
        }

        private void mostrarListaAnalisis()
        {
            try
            {
                // Relleno el arbol con los ficheros cargados y sus ejecuciones                
                ArrayList ficheros = fichero.getAll();

                Analisis analisis = new Analisis();
                ArrayList listaAnalisis;
                TreeNode nuevoNodo; 

                ficherosTree.Nodes.Clear();
                
                ficherosTree.Nodes.Add("Ficheros");

                    foreach (Fichero f in ficheros)
                    {

                        nuevoNodo = new TreeNode(f.Titulo);
                        ficherosTree.Nodes[0].Nodes.Add(nuevoNodo);
                        listaAnalisis = analisis.getByFicheroEstado(f.IdFichero, Estado.finalizado);

                        foreach (Analisis a in listaAnalisis)
                        {
                            nuevoNodo = new TreeNode(a.TipoAnalisis.Nombre + ": " + a.FechaInicio);
                            nuevoNodo.Name = a.IdAnalisis.ToString();
                            ficherosTree.Nodes[0].Nodes[ficheros.IndexOf(f)].Nodes.Add(nuevoNodo);
                        }

                    }
            }
            catch (DataAccessException dae)
            {
                MessageBox.Show("Error al obtener datos de los ficheros procesados de la base de datos: " + dae, "Error",
                    MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        private void adminProcesosToolStripMenuItem_Click(object sender, EventArgs e)
        {            
            new AdminProcesos().ShowDialog();
        }

        private void reportFicheros(){
            
            DataSetInformes dsPc = new DataSetInformes();
            SqlDataAdapter da;

            da = fichero.getAllSqlDataAdapter();
            da.Fill(dsPc, "Ficheros");

            Usuario usuarios = new Usuario();
            da = usuarios.getAllSqlDataAdapter();
            da.Fill(dsPc, "Usuarios");
            
            //Poblar el informe con el dataSet y mostrarlo
            CrystalReportFicheros info = new CrystalReportFicheros();
            info.SetDataSource(dsPc);
            crystalReportViewer1.ReportSource = info;
        }

        private void reportAnalisis(String nombreTipoAnalisis, int id_analisis)
        {

            DataSetInformes dsPc = new DataSetInformes();
            SqlDataAdapter da;

            da = fichero.getAllSqlDataAdapter();
            da.Fill(dsPc, "Ficheros");

            Origen origen = new Origen();
            da = origen.getAllSqlDataAdapter();
            da.Fill(dsPc, "Origen");

            Prioridad prioridad = new Prioridad();
            da = prioridad.getAllSqlDataAdapter();
            da.Fill(dsPc, "Prioridad");

            Estado estado = new Estado();
            da = estado.getAllSqlDataAdapter();
            da.Fill(dsPc, "Estados");

            TipoAnalisis tipoAnalisis = new TipoAnalisis();
            da = tipoAnalisis.getAllSqlDataAdapter();
            da.Fill(dsPc, "TipoAnalisis");

            Usuario usuarios = new Usuario();
            da = usuarios.getAllSqlDataAdapter();
            da.Fill(dsPc, "Usuarios");

            Analisis analisis = new Analisis();
            da = analisis.getAllSqlDataAdapter(id_analisis);
            da.Fill(dsPc, "Analisis");

            TPCANeuronal tPCANeuronal = new TPCANeuronal();
            da = tPCANeuronal.getAllSqlDataAdapter(id_analisis);
            da.Fill(dsPc, "PcaNeuronal");

            TMaximumLikelihood tMaximumLikelihood = new TMaximumLikelihood();
            da = tMaximumLikelihood.getAllSqlDataAdapter(id_analisis);
            da.Fill(dsPc, "MaximumLikelihood");

            TConexionesLaterales tConexionesLaterales = new TConexionesLaterales();
            da = tConexionesLaterales.getAllSqlDataAdapter(id_analisis);
            da.Fill(dsPc, "ConexionesLaterales");

            if (nombreTipoAnalisis == "PCA Estadistico")
            {
                CrystalReportAnalisisPCA info = new CrystalReportAnalisisPCA();
                info.SetDataSource(dsPc);
                crystalReportViewer1.ReportSource = info;
            }
            else if (nombreTipoAnalisis == "PCA Neuronal")
            {
                CrystalReportAnalisisPCANeuronal info = new CrystalReportAnalisisPCANeuronal();
                info.SetDataSource(dsPc);
                crystalReportViewer1.ReportSource = info;
            }
            else if (nombreTipoAnalisis == "MLHL")
            {
                CrystalReportAnalisisMaximumLikelihood info = new CrystalReportAnalisisMaximumLikelihood();
                info.SetDataSource(dsPc);
                crystalReportViewer1.ReportSource = info;
            }
            else if (nombreTipoAnalisis == "MLHLCL")
            {
                CrystalReportAnalisisConexionesLaterales info = new CrystalReportAnalisisConexionesLaterales();
                info.SetDataSource(dsPc);
                crystalReportViewer1.ReportSource = info;
            }            
        }

        private void ficherosTree_AfterSelect(object sender, TreeViewEventArgs e)
        {
            String tipoAnalisis;
            String aux;
            int id_analisis;
            String fichero;

            if (ficherosTree.SelectedNode.Parent == null)
            {
                reportFicheros();
            }
            else
            {
                //Si el nodo tiene padre
                if (ficherosTree.SelectedNode.Parent.Text == "Ficheros")
                {
                }
                else
                {

                    aux = ficherosTree.SelectedNode.Text;
                    tipoAnalisis = (aux.Split(':')[0]);
                    id_analisis = Int32.Parse(ficherosTree.SelectedNode.Name);

                    fichero = ficherosTree.SelectedNode.Parent.Text;

                    reportAnalisis(tipoAnalisis, id_analisis);

                }
            }            
        }

        private void crystalReportViewer1_Load(object sender, EventArgs e)
        {

        }

        /// <summary>
        /// Valida los campos del formulario segun el tipo de analisis
        /// </summary>
        /// <returns></returns>
        private Boolean validarForm()        
        {
            if (ficherosCombo.Text == "")
                return false;

            if (analisisCombo.Text == "PCANeuronal")
            {
                if (neuronasText.Text == "" || iteracionesText.Text == "" || coeficienteText.Text == "")
                    return false;
            }
            else if (analisisCombo.Text == "MLHL")
            {
                if (neuronasText.Text == "" || iteracionesText.Text == "" || coeficienteText.Text == "" || pText.Text == "")
                {
                    return false;
                }
            }
            else if (analisisCombo.Text == "MLHLCL")
            {
                if (neuronasText.Text == "" || iteracionesText.Text == "" || coeficienteText.Text == "" || pText.Text == "" || tauText.Text == "")
                {
                    return false;
                }
            }

            return true;


        }

        private void ficherosCombo_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (ficherosCombo.Items.Count > 0)
            {
                fichero.getByTitulo(ficherosCombo.Text);
                ficheroClasesText.Text = fichero.FicheroClases;
                ficheroDatosText.Text = fichero.FicheroDatos;

                // Selecciona todos los atributos del fichero
                String ficheroSeleccion = Path.GetTempFileName();

                using (StreamWriter streamWriter = new StreamWriter(ficheroSeleccion))
                {

                    using (CsvReader csv = new CsvReader(new StreamReader(fichero.FicheroDatos), true, ';'))
                    {
                        int fieldCount = csv.FieldCount;

                        String registroSeleccion;
                        
                        while (csv.ReadNextRecord())
                        {
                            registroSeleccion = "";

                            for (int i = 0; i < fieldCount; i++)
                            {
                                if (i != 0)
                                    registroSeleccion += ";";

                                registroSeleccion += csv[i];
                            }

                            streamWriter.WriteLine(registroSeleccion);                            
                        }
                    }
                }

                ficheroDatos = ficheroSeleccion;
                ficheroClases = fichero.FicheroClases;
                seleccionarDatosButton.Enabled = true;
            }
        }
                
        private void iniciar_Click(object sender, EventArgs e)
        {

            if (analisis != null)
            {
                DialogResult result = MessageBox.Show("Va a iniciar un nuevo análisis y perderá los cambios no guardados. ¿Está seguro?", "Confirmación de inicio",
                MessageBoxButtons.YesNo, MessageBoxIcon.Question);

                if (result == DialogResult.No)
                    return;
                else
                    analisisPicture.Image = null;
            }
            
            if (!validarForm())
            {
                MessageBox.Show("Debe completar todos los campos del formulario para poder iniciar el análisis", "Error de validación",
                MessageBoxButtons.OK, MessageBoxIcon.Stop);
            }
            else
            {
                analisis = new Analisis();

                analisis.Fichero = fichero;
                analisis.Usuario = Principal.UsuarioConectado;

                // Fecha de inicio
                DateTime dateTime = DateTime.Now;
                analisis.FechaInicio = dateTime;
                analisis.FechaFin = dateTime;

                // Estado cancelado hasta que se construya la informacion de ejecucion
                Estado estado = new Estado();
                estado.get(Estado.cancelado);
                analisis.Estado = estado;

                // Origen de la ejecucion
                Origen origen = new Origen();
                origen.get(Origen.aplicacion);
                analisis.Origen = origen;

                analisis.Prioridad = prioridad;

                // Tipo del analisis
                TipoAnalisis tipoAnalisis = new TipoAnalisis();
                switch (analisisCombo.Text)
                {
                    case "PCAEstadístico":
                        tipoAnalisis.get(TipoAnalisis.pcaEstadistico);
                        break;
                    case "PCANeuronal":
                        tipoAnalisis.get(TipoAnalisis.pcaNeuronal);
                        break;
                    case "MLHL":
                        tipoAnalisis.get(TipoAnalisis.maximumLikelihood);
                        break;
                    case "MLHLCL":
                        tipoAnalisis.get(TipoAnalisis.conexionesLaterales);
                        break;
                }
                analisis.TipoAnalisis = tipoAnalisis;

                analisis.Imagen = null;
                analisis.FicheroMatrizPesos = "";
                analisis.Conclusion = "";

                analisis.save();

                // Parametros del analisis
                switch (analisisCombo.Text)
                {
                    case "PCAEstadístico":
                        break;
                    case "PCANeuronal":
                        TPCANeuronal tPCANeuronal = new TPCANeuronal();
                        tPCANeuronal.NumeroNeuronas = Int32.Parse(neuronasText.Text);
                        tPCANeuronal.NumIteraciones = Int32.Parse(iteracionesText.Text);                        
                        tPCANeuronal.CoefiAprendizaje = Double.Parse(coeficienteText.Text, CultureInfo.CreateSpecificCulture("en-US"));
                        tPCANeuronal.IdAnalisis = analisis.IdAnalisis;
                        tPCANeuronal.save();
                        break;
                    case "MLHL":
                        TMaximumLikelihood tMaximum = new TMaximumLikelihood();
                        tMaximum.NumeroNeuronas = Int32.Parse(neuronasText.Text);
                        tMaximum.NumIteraciones = Int32.Parse(iteracionesText.Text);
                        tMaximum.CoefiAprendizaje = Double.Parse(coeficienteText.Text, CultureInfo.CreateSpecificCulture("en-US"));
                        tMaximum.P = Double.Parse(pText.Text, CultureInfo.CreateSpecificCulture("en-US"));
                        tMaximum.IdAnalisis = analisis.IdAnalisis;
                        tMaximum.save();
                        break;
                    case "MLHLCL":
                        TConexionesLaterales tConexiones = new TConexionesLaterales();
                        tConexiones.NumeroNeuronas = Int32.Parse(neuronasText.Text);
                        tConexiones.NumIteraciones = Int32.Parse(iteracionesText.Text);
                        tConexiones.CoefiAprendizaje = Double.Parse(coeficienteText.Text, CultureInfo.CreateSpecificCulture("en-US"));
                        tConexiones.P = Double.Parse(pText.Text, CultureInfo.CreateSpecificCulture("en-US"));
                        tConexiones.Tau = Double.Parse(tauText.Text, CultureInfo.CreateSpecificCulture("en-US"));
                        tConexiones.IdAnalisis = analisis.IdAnalisis;
                        tConexiones.save();
                        break;
                }

                // Si la ejecucion es programada
                if (programarCheck.Checked)
                {
                    // Programo la ejecucion una vez cargados los parametros de ejecucion
                    estado.get(Estado.programado);
                    analisis.Estado = estado;
                    analisis.save();

                    MessageBox.Show("El análisis ha sido programado para su ejecución. Una vez efectuado puede ver los resultados en la pestaña Informes", "Análisis programado",
                    MessageBoxButtons.OK, MessageBoxIcon.Information);
                }
                // Si no, disparo la ejecucion inmediatamente
                else
                {
                    // Actualizo estado
                    estado.get(Estado.ejecutando);
                    analisis.Estado = estado;
                    analisis.save();

                    AppSettingsReader appReader = new AppSettingsReader();
                    String stringType = "";
                    String dataDirectory = (String)appReader.GetValue("dataDirectory", stringType.GetType());

                    try
                    {

                        String ficheroImagen = null;
                        String ficheroPesos = null;

                        // Parametros del analisis
                        switch (analisisCombo.Text)
                        {
                            case "PCAEstadístico":
                                pcaEstadistico.ejecutar(ficheroDatos, ficheroClases, dataDirectory + @"\", mostrarEtiquetasCheck.Checked);
                                ficheroImagen = dataDirectory + @"\PCAEstadistico.jpg";
                                ficheroPesos = dataDirectory + @"\PCAEstadisticoPesos.txt";
                                break;
                            case "PCANeuronal":
                                pcaNeuronal.ejecutar(Double.Parse(neuronasText.Text), Double.Parse(coeficienteText.Text, CultureInfo.CreateSpecificCulture("en-US")), Double.Parse(iteracionesText.Text), ficheroDatos, ficheroClases, dataDirectory + @"\", mostrarEtiquetasCheck.Checked);
                                ficheroImagen = dataDirectory + @"\PCANeuronal.jpg";
                                ficheroPesos = dataDirectory + @"\PCANeuronalPesos.txt";                                
                                break;
                            case "MLHL":
                                maximumLikelihood.ejecutar(Double.Parse(neuronasText.Text), Double.Parse(coeficienteText.Text, CultureInfo.CreateSpecificCulture("en-US")), Double.Parse(pText.Text, CultureInfo.CreateSpecificCulture("en-US")), Double.Parse(iteracionesText.Text), ficheroDatos, ficheroClases, dataDirectory + @"\", mostrarEtiquetasCheck.Checked);
                                ficheroImagen = dataDirectory + @"\MaximumLikelihood.jpg";
                                ficheroPesos = dataDirectory + @"\MaximumLikelihoodPesos.txt";                                
                                break;
                            case "MLHLCL":
                                conexionesLaterales.ejecutar(Double.Parse(neuronasText.Text), Double.Parse(coeficienteText.Text, CultureInfo.CreateSpecificCulture("en-US")), Double.Parse(pText.Text, CultureInfo.CreateSpecificCulture("en-US")), Double.Parse(tauText.Text, CultureInfo.CreateSpecificCulture("en-US")), Double.Parse(iteracionesText.Text), ficheroDatos, ficheroClases, dataDirectory + @"\", mostrarEtiquetasCheck.Checked);
                                ficheroImagen = dataDirectory + @"\ConexionesLaterales.jpg";
                                ficheroPesos = dataDirectory + @"\ConexionesLateralesPesos.txt";                                                                
                                break;
                        }

                        // Visualizo la imagen resultado
                        using (FileStream imageStream = new FileStream(ficheroImagen, FileMode.Open, FileAccess.Read))
                        {
                            analisisPicture.Image = System.Drawing.Image.FromStream(imageStream);
                            
                            // Asigno los pesos al analisis
                            using (StreamReader pesosReader = new StreamReader(ficheroPesos))
                            {
                                analisis.FicheroMatrizPesos = pesosReader.ReadToEnd();
                            }
                            
                            // Asigno la imagen al analisis
                            analisis.Imagen = analisisPicture.Image;

                            // Fecha de inicio
                            dateTime = DateTime.Now;
                            analisis.FechaFin = dateTime;

                            // Actualizo estado
                            estado.get(Estado.finalizado);
                            analisis.Estado = estado;
                            analisis.save();
                        }

                        // Elimino los ficheros temporales
                        File.Delete(ficheroImagen);
                        File.Delete(ficheroPesos);

                        // Habilito guardar imagen
                        guardarImagenStripMenuItem.Enabled = true;
                    }
                    catch (Exception ex)
                    {
                        MessageBox.Show("Ha ocurrido una excepción al ejecutar el análisis: " + ex, "Error de ejecución", 
                            MessageBoxButtons.OK, MessageBoxIcon.Stop);                        
                    }
                }

                // Habilito guardar
                guardarButton.Enabled = true;
                guardarToolStripMenuItem.Enabled = true;
            }
        }

        private void analisisCombo_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (analisisCombo.Text == "PCAEstadístico")
            {
                neuronasText.Enabled = false;
                iteracionesText.Enabled = false;
                coeficienteText.Enabled = false;
                pText.Enabled = false;
                tauText.Enabled = false;
                richTextBox1.LoadFile(System.IO.Directory.GetCurrentDirectory() + @"\PCAEstadistico.rtf");
            }
            else if (analisisCombo.Text == "PCANeuronal")
            {
                neuronasText.Enabled = true;
                neuronasText.Text = "3";
                iteracionesText.Enabled = true;
                iteracionesText.Text = "1000";
                coeficienteText.Enabled = true;
                coeficienteText.Text = "0.01";
                pText.Enabled = false;
                tauText.Enabled = false;
                richTextBox1.LoadFile(System.IO.Directory.GetCurrentDirectory() + @"\PCANeuronal.rtf");
            }
            else if (analisisCombo.Text == "MLHL")
            {
                neuronasText.Enabled = true;
                neuronasText.Text = "3";
                iteracionesText.Enabled = true;
                iteracionesText.Text = "1000";
                coeficienteText.Enabled = true;
                coeficienteText.Text = "0.01";
                pText.Enabled = true;
                pText.Text = "0.01";
                tauText.Enabled = false;
                richTextBox1.LoadFile(System.IO.Directory.GetCurrentDirectory() + @"\MaximumLikelihood.rtf");
            }
            else if (analisisCombo.Text == "MLHLCL")
            {
                neuronasText.Enabled = true;
                neuronasText.Text = "3";
                iteracionesText.Enabled = true;
                iteracionesText.Text = "1000";
                coeficienteText.Enabled = true;
                coeficienteText.Text = "0.01";
                pText.Enabled = true;
                pText.Text = "0.01";
                tauText.Enabled = true;
                tauText.Text = "0.04";
                richTextBox1.LoadFile(System.IO.Directory.GetCurrentDirectory() + @"\ConexionesLaterales.rtf");
            }
        }

        // Abre el cuadro de dialogo de importar ficheros
        private void importarButton_Click(object sender, EventArgs e)
        {
            new ImportarDatos().ShowDialog();

            cargarListaFicheros();            
        }

        /// <summary>
        /// Guarda el comentario en el analisis efectuado
        /// </summary>
        private void guardarButton_Click(object sender, EventArgs e)
        {
            analisis.Conclusion = comentarioText.Text;
            analisis.updateConclusion();

            MessageBox.Show("El análisis ha sido guardado.", "Análisis guardado",
            MessageBoxButtons.OK, MessageBoxIcon.Information);
        }
                
        private void nuevoToolStripMenuItem_Click(object sender, EventArgs e)
        {            
        }

        private void guardarToolStripMenuItem_Click(object sender, EventArgs e)
        {
            guardarButton_Click(sender, e);
        }

        /// <summary>
        /// Guardo la imagen en disco
        /// </summary>
        private void guardarImagenStripMenuItem_Click(object sender, EventArgs e)
        {
            saveFileDialog1.FileName = "";
            saveFileDialog1.Filter = "jpeg files (*.jpg)|*.jpg|All files (*.*)|*.*";
            saveFileDialog1.FilterIndex = 1;
            saveFileDialog1.RestoreDirectory = true;
            if (saveFileDialog1.ShowDialog() == DialogResult.OK)
                analisisPicture.Image.Save(saveFileDialog1.FileName);
        }

        /// <summary>
        /// Abrimos un analisis para mostrar sus datos
        /// </summary>
        private void abrirToolStripMenuItem_Click(object sender, EventArgs e)
        {
            new AbrirAnalisis().ShowDialog();

            // Cargo la informacion del analisis
            if (analisis != null)
            {
                switch (analisis.TipoAnalisis.IdTipoAnalisis) {
                    // Analisis PCAEstadistico
                    case TipoAnalisis.pcaEstadistico:
                        analisisCombo.SelectedIndex = 0;                        
                        break;
                    // Analisis PCANeuronal
                    case TipoAnalisis.pcaNeuronal: 
                        TPCANeuronal analisisNeuronal = new TPCANeuronal();
                        analisisNeuronal.get(analisis.IdAnalisis);
                        analisisCombo.SelectedIndex = 1;

                        neuronasText.Text = analisisNeuronal.NumeroNeuronas.ToString();
                        iteracionesText.Text = analisisNeuronal.NumIteraciones.ToString();
                        coeficienteText.Text = analisisNeuronal.CoefiAprendizaje.ToString();
                        break;
                    case TipoAnalisis.maximumLikelihood:
                        TMaximumLikelihood analisisMaximumLikelihood = new TMaximumLikelihood();
                        analisisMaximumLikelihood.get(analisis.IdAnalisis);                        
                        analisisCombo.SelectedIndex = 2;

                        neuronasText.Text = analisisMaximumLikelihood.NumeroNeuronas.ToString();
                        iteracionesText.Text = analisisMaximumLikelihood.NumIteraciones.ToString();
                        coeficienteText.Text = analisisMaximumLikelihood.CoefiAprendizaje.ToString();
                        pText.Text = analisisMaximumLikelihood.P.ToString();
                        break;
                    case TipoAnalisis.conexionesLaterales:
                        analisisCombo.SelectedIndex = 3;

                        TConexionesLaterales analisisConexionesLaterales = new TConexionesLaterales();
                        analisisConexionesLaterales.get(analisis.IdAnalisis);

                        neuronasText.Text = analisisConexionesLaterales.NumeroNeuronas.ToString();
                        iteracionesText.Text = analisisConexionesLaterales.NumIteraciones.ToString();
                        coeficienteText.Text = analisisConexionesLaterales.CoefiAprendizaje.ToString();
                        pText.Text = analisisConexionesLaterales.P.ToString();
                        tauText.Text = analisisConexionesLaterales.Tau.ToString();
                        
                        break;
                }

                ficheroClasesText.Text = analisis.Fichero.FicheroClases;
                ficheroDatosText.Text = analisis.Fichero.FicheroDatos;
                comentarioText.Text = analisis.Conclusion;
                analisisPicture.Image = analisis.Imagen;

                analisisCombo.Enabled = false;
                ficherosCombo.Enabled = false;
                importarButton.Enabled = false;
                programarCheck.Enabled = false;
                iniciarButton.Enabled = false;
                guardarButton.Enabled = true;
                guardarToolStripMenuItem.Enabled = true;
                guardarImagenStripMenuItem.Enabled = true;
                prioridadCombo.Enabled = false;
            }
        }

        private void prioridadCombo_SelectedIndexChanged(object sender, EventArgs e)
        {
            ArrayList prioridades = prioridad.getAll();
            foreach (Prioridad p in prioridades)
            {
                if (prioridadCombo.Text.Equals(p.Nivel))
                {
                    Prioridad = p;
                    break;
                }
            }
        }

        private void programarCheck_CheckedChanged(object sender, EventArgs e)
        {
            if (programarCheck.Checked == true)
                prioridadCombo.Enabled = true;
            else
                prioridadCombo.Enabled = false;
        }

        private void recargarToolStripMenuItem_Click(object sender, EventArgs e)
        {
            // muestro la lista de analisis ejecutados
            mostrarListaAnalisis();
            // Crea el reporte
            reportFicheros();
        }

        /**
         * Limpia los controles para iniciar un analisis nuevo
         */
        private void nuevoToolStripMenuItem_Click_1(object sender, EventArgs e)
        {
            analisisCombo.Enabled = true;
            ficherosCombo.Enabled = true;
            analisisPicture.Image = null;
            guardarButton.Enabled = false;
            iniciarButton.Enabled = true;
            importarButton.Enabled = true;
            programarCheck.Enabled = true;
            if (ficherosCombo.Items.Count > 0)
                ficherosCombo.SelectedIndex = 0;
            comentarioText.Text = "";
            guardarImagenStripMenuItem.Enabled = false;
        }

        private void seleccionarDatosButton_Click(object sender, EventArgs e)
        {
            SeleccionarDatos seleccionarDatos = new SeleccionarDatos();
            seleccionarDatos.FicheroDatos = fichero.FicheroDatos;
            seleccionarDatos.FicheroClases = fichero.FicheroClases;
            seleccionarDatos.ShowDialog();
            ficheroDatos = seleccionarDatos.FicheroDatos;
            ficheroClases = seleccionarDatos.FicheroClases;
        }

        private void groupBox1_Enter(object sender, EventArgs e)
        {

        }

        private void Principal_HelpRequested(object sender, HelpEventArgs hlpevent)
        {
            Help.ShowHelp(this, "AdmacoHelp.chm", HelpNavigator.TopicId, "2");
        }

        private void índiceToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Help.ShowHelp(this, "AdmacoHelp.chm", HelpNavigator.TopicId, "2");
        }
    }
}  